package com.caseprocessing.config;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * AI服务配置管理器
 * 负责加载和管理AI相关的配置参数
 */
public class AIConfig {
    
    private static final String CONFIG_FILE = "ai-config.properties";
    private static AIConfig instance;
    private final Properties properties;
    private final ConcurrentMap<String, String> overrides;
    
    private AIConfig() {
        this.properties = new Properties();
        this.overrides = new ConcurrentHashMap<>();
        loadConfiguration();
    }
    
    /**
     * 获取配置实例（单例模式）
     */
    public static synchronized AIConfig getInstance() {
        if (instance == null) {
            instance = new AIConfig();
        }
        return instance;
    }
    
    /**
     * 加载配置文件
     */
    private void loadConfiguration() {
        try (InputStream inputStream = getClass().getClassLoader().getResourceAsStream(CONFIG_FILE)) {
            if (inputStream != null) {
                properties.load(inputStream);
                System.out.println("✅ AI配置文件加载成功: " + CONFIG_FILE);
            } else {
                System.err.println("⚠️ 配置文件未找到: " + CONFIG_FILE + "，使用默认配置");
                loadDefaultConfiguration();
            }
        } catch (IOException e) {
            System.err.println("❌ 配置文件加载失败: " + e.getMessage());
            loadDefaultConfiguration();
        }
    }
    
    /**
     * 加载默认配置
     */
    private void loadDefaultConfiguration() {
        properties.setProperty("siliconflow.api.key", "your_api_key_here");
        properties.setProperty("siliconflow.api.base.url", "https://api.siliconflow.cn/v1/chat/completions");
        properties.setProperty("siliconflow.api.timeout", "30000");
        properties.setProperty("siliconflow.api.retry.attempts", "3");
        
        properties.setProperty("llm.model.name", "deepseek-ai/DeepSeek-V3");
        properties.setProperty("llm.model.max.tokens", "4096");
        properties.setProperty("llm.model.temperature", "0.7");
        properties.setProperty("llm.model.top.p", "0.9");
        
        properties.setProperty("vlm.model.name", "Qwen/QVQ-72B-Preview");
        properties.setProperty("vlm.model.max.tokens", "4096");
        properties.setProperty("vlm.model.temperature", "0.7");
        properties.setProperty("vlm.model.top.p", "0.9");
        
        properties.setProperty("processing.batch.size", "10");
        properties.setProperty("processing.max.concurrency", "5");
        properties.setProperty("processing.timeout.seconds", "300");
        properties.setProperty("quality.confidence.threshold", "0.7");
    }
    
    /**
     * 获取配置值
     */
    public String getProperty(String key) {
        // 优先检查运行时覆盖
        String override = overrides.get(key);
        if (override != null) {
            return override;
        }
        
        // 检查系统属性
        String systemProperty = System.getProperty(key);
        if (systemProperty != null) {
            return systemProperty;
        }
        
        // 检查环境变量
        String envKey = key.toUpperCase().replace('.', '_');
        String envValue = System.getenv(envKey);
        if (envValue != null) {
            return envValue;
        }
        
        // 返回配置文件中的值
        return properties.getProperty(key);
    }
    
    /**
     * 获取配置值（带默认值）
     */
    public String getProperty(String key, String defaultValue) {
        String value = getProperty(key);
        return value != null ? value : defaultValue;
    }
    
    /**
     * 获取整数配置值
     */
    public int getIntProperty(String key, int defaultValue) {
        String value = getProperty(key);
        if (value != null) {
            try {
                return Integer.parseInt(value);
            } catch (NumberFormatException e) {
                System.err.println("⚠️ 配置值格式错误: " + key + " = " + value + "，使用默认值: " + defaultValue);
            }
        }
        return defaultValue;
    }
    
    /**
     * 获取双精度配置值
     */
    public double getDoubleProperty(String key, double defaultValue) {
        String value = getProperty(key);
        if (value != null) {
            try {
                return Double.parseDouble(value);
            } catch (NumberFormatException e) {
                System.err.println("⚠️ 配置值格式错误: " + key + " = " + value + "，使用默认值: " + defaultValue);
            }
        }
        return defaultValue;
    }
    
    /**
     * 获取布尔配置值
     */
    public boolean getBooleanProperty(String key, boolean defaultValue) {
        String value = getProperty(key);
        if (value != null) {
            return Boolean.parseBoolean(value);
        }
        return defaultValue;
    }
    
    /**
     * 运行时设置配置值
     */
    public void setProperty(String key, String value) {
        overrides.put(key, value);
    }
    
    /**
     * 移除运行时覆盖
     */
    public void removeOverride(String key) {
        overrides.remove(key);
    }
    
    /**
     * 清除所有运行时覆盖
     */
    public void clearOverrides() {
        overrides.clear();
    }
    
    // ============ 常用配置项的便捷方法 ============
    
    /**
     * 获取SiliconFlow API密钥
     */
    public String getApiKey() {
        return getProperty("siliconflow.api.key");
    }
    
    /**
     * 设置API密钥
     */
    public void setApiKey(String apiKey) {
        setProperty("siliconflow.api.key", apiKey);
    }
    
    /**
     * 获取API基础URL
     */
    public String getApiBaseUrl() {
        return getProperty("siliconflow.api.base.url", "https://api.siliconflow.cn/v1/chat/completions");
    }
    
    /**
     * 获取API超时时间
     */
    public int getApiTimeout() {
        return getIntProperty("siliconflow.api.timeout", 30000);
    }
    
    /**
     * 获取API重试次数
     */
    public int getApiRetryAttempts() {
        return getIntProperty("siliconflow.api.retry.attempts", 3);
    }
    
    /**
     * 获取LLM模型名称
     */
    public String getLlmModelName() {
        return getProperty("llm.model.name", "deepseek-ai/DeepSeek-V3");
    }
    
    /**
     * 获取VLM模型名称
     */
    public String getVlmModelName() {
        return getProperty("vlm.model.name", "Qwen/QVQ-72B-Preview");
    }
    
    /**
     * 获取LLM最大Token数
     */
    public int getLlmMaxTokens() {
        return getIntProperty("llm.model.max.tokens", 4096);
    }
    
    /**
     * 获取VLM最大Token数
     */
    public int getVlmMaxTokens() {
        return getIntProperty("vlm.model.max.tokens", 4096);
    }
    
    /**
     * 获取LLM温度参数
     */
    public double getLlmTemperature() {
        return getDoubleProperty("llm.model.temperature", 0.7);
    }
    
    /**
     * 获取VLM温度参数
     */
    public double getVlmTemperature() {
        return getDoubleProperty("vlm.model.temperature", 0.7);
    }
    
    /**
     * 获取LLM Top-P参数
     */
    public double getLlmTopP() {
        return getDoubleProperty("llm.model.top.p", 0.9);
    }
    
    /**
     * 获取VLM Top-P参数
     */
    public double getVlmTopP() {
        return getDoubleProperty("vlm.model.top.p", 0.9);
    }
    
    /**
     * 获取文档分析系统提示词
     */
    public String getDocumentAnalysisPrompt() {
        return getProperty("system.prompt.document.analysis", 
            "你是一个专业的法律文书分析助手，请仔细分析文档内容并提供准确的分析结果。");
    }
    
    /**
     * 获取合规检查系统提示词
     */
    public String getComplianceCheckPrompt() {
        return getProperty("system.prompt.compliance.check", 
            "你是一个专业的合规检查助手，请根据法律法规检查文档的合规性。");
    }
    
    /**
     * 获取自然语言交互系统提示词
     */
    public String getNaturalLanguagePrompt() {
        return getProperty("system.prompt.natural.language", 
            "你是一个专业的案卷文书处理助手，请用简洁明了的语言回答用户问题。");
    }
    
    /**
     * 获取批处理大小
     */
    public int getBatchSize() {
        return getIntProperty("processing.batch.size", 10);
    }
    
    /**
     * 获取最大并发数
     */
    public int getMaxConcurrency() {
        return getIntProperty("processing.max.concurrency", 5);
    }
    
    /**
     * 获取处理超时时间（秒）
     */
    public int getProcessingTimeout() {
        return getIntProperty("processing.timeout.seconds", 300);
    }
    
    /**
     * 获取质量置信度阈值
     */
    public double getQualityConfidenceThreshold() {
        return getDoubleProperty("quality.confidence.threshold", 0.7);
    }
    
    /**
     * 是否启用缓存
     */
    public boolean isCacheEnabled() {
        return getBooleanProperty("processing.enable.cache", true);
    }
    
    /**
     * 获取缓存TTL（分钟）
     */
    public int getCacheTtlMinutes() {
        return getIntProperty("processing.cache.ttl.minutes", 60);
    }
    
    /**
     * 是否启用API日志
     */
    public boolean isApiLogsEnabled() {
        return getBooleanProperty("logging.enable.api.logs", true);
    }
    
    /**
     * 是否启用性能日志
     */
    public boolean isPerformanceLogsEnabled() {
        return getBooleanProperty("logging.enable.performance.logs", true);
    }
    
    /**
     * 获取日志级别
     */
    public String getLogLevel() {
        return getProperty("logging.level", "INFO");
    }
    
    /**
     * 验证配置完整性
     */
    public boolean validateConfiguration() {
        boolean valid = true;
        
        // 检查必要的配置项
        if (getApiKey() == null || "your_api_key_here".equals(getApiKey())) {
            System.err.println("❌ API密钥未配置或使用默认值");
            valid = false;
        }
        
        if (getApiBaseUrl() == null || getApiBaseUrl().trim().isEmpty()) {
            System.err.println("❌ API基础URL未配置");
            valid = false;
        }
        
        if (getLlmModelName() == null || getLlmModelName().trim().isEmpty()) {
            System.err.println("❌ LLM模型名称未配置");
            valid = false;
        }
        
        if (getVlmModelName() == null || getVlmModelName().trim().isEmpty()) {
            System.err.println("❌ VLM模型名称未配置");
            valid = false;
        }
        
        // 检查数值参数的合理性
        if (getApiTimeout() <= 0) {
            System.err.println("❌ API超时时间配置无效");
            valid = false;
        }
        
        if (getLlmMaxTokens() <= 0 || getVlmMaxTokens() <= 0) {
            System.err.println("❌ 模型最大Token数配置无效");
            valid = false;
        }
        
        if (getLlmTemperature() < 0 || getLlmTemperature() > 2 || 
            getVlmTemperature() < 0 || getVlmTemperature() > 2) {
            System.err.println("❌ 模型温度参数配置无效");
            valid = false;
        }
        
        if (valid) {
            System.out.println("✅ 配置验证通过");
        }
        
        return valid;
    }
    
    /**
     * 打印当前配置
     */
    public void printConfiguration() {
        System.out.println("\n📋 当前AI配置:");
        System.out.println("=" .repeat(50));
        System.out.println("API基础URL: " + getApiBaseUrl());
        System.out.println("API超时时间: " + getApiTimeout() + "ms");
        System.out.println("API重试次数: " + getApiRetryAttempts());
        System.out.println("LLM模型: " + getLlmModelName());
        System.out.println("VLM模型: " + getVlmModelName());
        System.out.println("LLM最大Token: " + getLlmMaxTokens());
        System.out.println("VLM最大Token: " + getVlmMaxTokens());
        System.out.println("LLM温度: " + getLlmTemperature());
        System.out.println("VLM温度: " + getVlmTemperature());
        System.out.println("批处理大小: " + getBatchSize());
        System.out.println("最大并发数: " + getMaxConcurrency());
        System.out.println("处理超时: " + getProcessingTimeout() + "s");
        System.out.println("质量阈值: " + getQualityConfidenceThreshold());
        System.out.println("启用缓存: " + isCacheEnabled());
        System.out.println("日志级别: " + getLogLevel());
        System.out.println("=" .repeat(50));
    }
}